import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.util.*;

public class BookSystem {
    public static void main(String[] args) {
        new LoginFrame().setVisible(true);//创建并显示登录界面
    }
}


//登录界面
class LoginFrame extends JFrame {
    //创建用户选择选择框
    private JComboBox<String> roleCombo = new JComboBox<>(new String[]{"用户", "管理员"});
    //创建账号和密码输入框
    private JTextField userField = new JTextField(15);//设置文本框的宽度为15个字符
    //JPasswordField是一个用于输入密码的文本框组件，继承自JTextField，自带将输入的字符显示为圆点的功能，
    private JPasswordField passField = new JPasswordField(15);

    //构造方法
    public LoginFrame() {
        super("图书管理系统登录");//调用父类JFrame的构造方法，设置窗口标题
        setupUI(); //调用setupUI()方法，实现界面的布局设置
        setSize(400, 320);//设置窗口的大小为400x320像素
        setLocationRelativeTo(null);//设置窗口相对于电脑屏幕的位置为居中
        setDefaultCloseOperation(EXIT_ON_CLOSE);//设置窗口关闭时的默认操作为退出程序
    }

    //设置界面布局
    private void setupUI() {
        //设置登录界面的布局
        //JPanel是一个容器组件，用于容纳其他组件。
        //BorderLayout是一种布局管理器，它将容器划分为五个区域：北、南、东、西和中。
        JPanel mainPanel = new JPanel(new BorderLayout(10, 15));//设置每个组件之间的水平和垂直间距为10和15像素。
        //设置主面板的边框，包括一个黑色的实线边框和内边距。
        //CompoundBorder是一个复合边框，它由两个边框组成，一个在另一个的外面。
        //LineBorder是一个边框，它绘制一个矩形边框。
        //EmptyBorder是一个边框，它不绘制任何内容，只是提供了一个空的边界。
        mainPanel.setBorder(new CompoundBorder(
                new LineBorder(Color.BLACK, 2),//设置边框的颜色为黑色，宽度为2像素。
                new EmptyBorder(25, 40, 25, 40)//设置边框的内边距，分别为顶部、左侧、底部和右侧的间距为25和40像素。
        ));


        // 设置标题
        // 创建一个标签，用于显示标题文本，并将其居中对齐。
        JLabel titleLabel = new JLabel("图书管理系统", SwingConstants.CENTER);
        //设置标题标签的字体为微软雅黑，字体样式为粗体，字体大小为22像素。
        titleLabel.setFont(new Font("微软雅黑", Font.BOLD, 22));
        //将标题标签添加到主面板的北部区域
        mainPanel.add(titleLabel, BorderLayout.NORTH);


        // 设置输入区域
        // 创建一个Jpanel用于容纳中部区的输入组件，并设置布局为网格布局，设有3行，行一个组件，水平间距为10像素，垂直间距为8像素。
        JPanel centerPanel = new JPanel(new GridLayout(4, 1, 10, 8));
        //调用createInputPanel方法，创建一个包含标签和文本框的面板，并将其添加到中部面板中。
        centerPanel.add(createInputPanel("账号:", userField));
        centerPanel.add(createInputPanel("密码:", passField));

        // 身份选择
        // 创建一个JPanel用于容纳身份选择组件，并设置布局为流式布局，左对齐。
        JPanel rolePanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
        //将“身份:”标签添加到身份选择面板中。
        rolePanel.add(new JLabel("身份:   "));
        //将身份选择框添加到身份选择面板中。
        rolePanel.add(roleCombo);
        //将身份选择面板添加到中部面板中CenterPanel容器中
        centerPanel.add(rolePanel);

        // 登录按钮
        // 创建一个“登录”按钮
        JButton btnLogin = new JButton("登  录");
        //设置按钮的字体为微软雅黑，字体样式为粗体，字体大小为14像素。
        btnLogin.setFont(new Font("微软雅黑", Font.BOLD, 14));
        //设置按钮的背景颜色为蓝色,
        btnLogin.setBackground(new Color(70, 130, 180));
        //设置按钮的前景(字体)颜色为白色
        btnLogin.setForeground(Color.WHITE);
        //为按钮添加一个动作监听器，当按钮被点击时，执行checkLogin()方法
        btnLogin.addActionListener(new ActionListener() {
            //当按钮被点击时，执行checkLogin()方法
            //这是一个匿名内部类，实现了ActionListener接口，用于处理按钮点击事件。
            @Override
            public void actionPerformed(ActionEvent e) {
                checkLogin();
            }
        });
        //btnLogin.addActionListener(e -> checkLogin());//使用Lambda表达式简化代码


        //将中部面板和登录按钮添加到主面板中
        mainPanel.add(centerPanel, BorderLayout.CENTER);//将中部面板添加到主面板的中部区域
        mainPanel.add(btnLogin, BorderLayout.SOUTH);//将登录按钮添加到主面板的南部区域
        add(mainPanel);//将主面板添加到窗口中
    }

    //创建输入面板的方法，接受标签和文本框作为参数
    private JPanel createInputPanel(String label, JTextField field) {
        //创建一个JPanel用于容纳标签和文本框，并设置布局为边界布局，水平间距为10像素，垂直间距为0像素。
        JPanel panel = new JPanel(new BorderLayout(10, 0));
        //创建一个标签，用于显示输入框的标签文本
        JLabel lbl = new JLabel(label);
        //设置标签的字体为宋体，字体样式为普通，字体大小为14像素。
        lbl.setFont(new Font("宋体", Font.PLAIN, 14));
        //设置文本框的边框为浅色灰色的实线边框
        field.setBorder(new LineBorder(Color.LIGHT_GRAY));
        //将标签和文本框添加到面板中
        panel.add(lbl, BorderLayout.WEST);//将标签添加到面板的西部区域
        panel.add(field, BorderLayout.CENTER);//将文本框添加到面板的中心区域
        return panel;//返回创建的输入面板
    }

    // 检查登录信息的方法
    private void checkLogin() {
        //将用户输入的账号和密码分别存储在变量username和password中，同时去除前后的空白字符。
        String username = userField.getText().trim();
        String password = new String(passField.getPassword()).trim();
        //获取身份选择框中选中的身份，并将其存储在变量role中
        String role = (String) roleCombo.getSelectedItem();
        //根据身份选择框中选中的身份，选择相应的文件名
        String filename = "用户".equals(role) ? "selfStudy\\schoolWork\\JavaShiXun\\users.txt" : "selfStudy\\schoolWork\\JavaShiXun\\admin.txt";

        //打开文件并读取用户信息，检查用户名和密码是否匹配
        try (Scanner sc = new Scanner(new File(filename))) {
            //遍历文件中的每一行
            while (sc.hasNextLine()) {
                //将当前行按逗号分隔成两个部分，分别存储在变量parts[0]和parts[1]中
                String[] parts = sc.nextLine().split(",");
                //检查用户名和密码是否匹配
                if (parts.length == 2 && parts[0].equals(username) && parts[1].equals(password)) {
                    //如果匹配成功，创建并显示主界面，传递用户名和身份信息给后续操作图书主界面的构造方法
                    new MainFrame(username, "管理员".equals(role)).setVisible(true);
                    dispose();//关闭当前登录界面
                    return;
                }
            }
            //如果没有找到匹配的用户名和密码，弹出对话框提示用户认证失败
            JOptionPane.showMessageDialog(this, "认证失败");
        } catch (FileNotFoundException e) {
            //如果文件不存在，弹出对话框提示用户数据文件不存在
            JOptionPane.showMessageDialog(this, "数据文件不存在");
        }
    }
}

//图书管理主界面
class MainFrame extends JFrame {
    //创建一个BookManager对象，用于管理图书信息
    private BookManager manager = new BookManager();
    //用于判断当前用户是否为管理员
    private boolean isAdmin;

    //构造方法，接受用户名和身份信息作为参数
    public MainFrame(String username, boolean isAdmin) {
        //调用父类JFrame的构造方法，设置窗口标题为“图书管理系统 - 管理员/用户 用户名”
        super("图书管理系统 - " + (isAdmin ? "管理员" : "用户") + " " + username);
        //设置当前用户是否为管理员
        this.isAdmin = isAdmin;
        setupUI(); //调用setupUI()方法，实现界面的布局设置
        setSize(700, 450);//设置窗口的大小为700x450像素
        setLocationRelativeTo(null); //设置窗口相对于电脑屏幕的位置为居中
        setDefaultCloseOperation(EXIT_ON_CLOSE); //设置窗口关闭时的默认操作为退出程序
        manager.loadBooks();//加载图书信息
    }

    //设置界面布局
    private void setupUI() {
        //创建一个JPanel作为主面板，并设置布局为边界布局
        //使用网格布局，将按钮分为两列，水平间距为15像素，垂直间距为15像素。
        JPanel btnPanel = new JPanel(new GridLayout(0, 2, 15, 15));
        //设置按钮面板的边框,EmptyBorder是一个边框，它不绘制任何内容，只是提供了一个空的边界。
        //设置按钮面板的边框为一个空的边界，上下左右各有20像素的空白区域。
        btnPanel.setBorder(new EmptyBorder(20, 40, 20, 40));

        //创建一个字符串数组，用于存储按钮的标签
        ArrayList<String> buttons = new ArrayList<>(Arrays.asList(
                "借阅图书", "归还图书", "书号查询", "书名查询",
                "作者查询", "显示全部", "退出系统"
        ));

        //如果当前用户是管理员，添加一些额外的按钮
        if (isAdmin) {
            //将“添加图书”按钮添加到按钮数组的开头
            buttons.add(0, "添加图书");
            //将“书号删除”、“书名删除”、“作者删除”按钮添加到按钮数组的末尾
            buttons.addAll(Arrays.asList("书号删除", "书名删除", "作者删除"));
        }

        //遍历按钮数组，创建并添加按钮到按钮面板中
        for (String label : buttons) {
            //创建一个JButton对象，用于表示按钮
            JButton btn = new JButton(label);
            //设置按钮的字体为微软雅黑，字体样式为普通，字体大小为14像素。
            btn.setFont(new Font("微软雅黑", Font.PLAIN, 14));
            //为按钮添加一个动作监听器，当按钮被点击时，执行handleAction()方法
            btn.addActionListener(this::handleAction);
            /*
            原理:this::handleAction表示引用当前对象的 handleAction 实例方法
            要求该方法签名与 ActionListener 的 actionPerformed 方法匹配（即无返回值、参数为 ActionEvent）。
            等价写法（传统匿名内部类）：btn.addActionListener(e -> handleAction());
             */
            //将按钮添加到按钮面板中
            btnPanel.add(btn);
        }
        //将按钮面板添加到窗口中
        add(btnPanel);
    }

    //处理按钮点击事件的方法，接受一个ActionEvent对象作为参数
    private void handleAction(ActionEvent e) {
        //获取按钮的文本标签，并根据标签执行相应的操作
        //e.getSource()方法返回触发事件的组件，即按钮本身。
        //(JButton)e.getSource()将该组件转换为JButton类型，以便可以调用其方法和属性。
        //.getText()方法用于获取按钮的文本标签。
        String cmd = ((JButton) e.getSource()).getText();
        switch (cmd) {
            case "添加图书": addBook(); break;
            case "借阅图书": borrowBook(); break;
            case "归还图书": returnBook(); break;
            case "退出系统": exitSystem(); break;
            case "显示全部": showAll(); break;
            case "书号删除":
            case "书名删除":
            case "作者删除": deleteBook(cmd.replace("删除", "")); break;
            default: searchBook(cmd.replace("查询", "").trim());
        }
    }

    //添加图书的方法
    private void addBook() {
        //创建一个JPanel对象，用于容纳输入组件
        JTextField[] fields = new JTextField[4];
        //使用网格布局，将输入组件分为四行两列，水平间距为10像素，垂直间距为10像素。
        JPanel panel = new JPanel(new GridLayout(4, 2, 10, 10));
        //创建一个字符串数组，用于存储输入组件的标签
        String[] labels = {"书号:", "书名:", "作者:", "数量:"};

        //遍历标签数组，创建标签和文本框，并将它们添加到输入面板中
        for (int i = 0; i < 4; i++) {
            panel.add(new JLabel(labels[i]));
            fields[i] = new JTextField();
            panel.add(fields[i]);
        }

        //显示一个对话框，用于输入图书信息
        //this表示当前窗口，即MainFrame对象
        //panel表示要显示的组件，即输入面板
        //"新增图书"表示对话框的标题
        //JOptionPane.OK_CANCEL_OPTION表示对话框的类型，即包含确定和取消按钮
        //JOptionPane.PLAIN_MESSAGE表示对话框的样式，即普通的消息框
        //result变量用于存储用户的选择结果，即用户点击的按钮
        int result = JOptionPane.showConfirmDialog(this, panel, "新增图书",
                JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);

        //如果用户点击了确定按钮
        if (result == JOptionPane.OK_OPTION) {
            try {
                //检查用户输入的信息是否完整
                for(JTextField s: fields) if(s.getText().isEmpty()) throw new Exception();
                //获取用户输入的图书信息，并创建一个Book对象
                //将Book对象添加到图书管理器中
                manager.addBook(new Book(
                        fields[0].getText().toUpperCase(),//使书号有字母时，都是大写存入
                        fields[1].getText(),
                        fields[2].getText(),
                        Integer.parseInt(fields[3].getText())
                ));
                //显示一个对话框，提示添加成功
                JOptionPane.showMessageDialog(this, "添加成功");
            } catch (NumberFormatException ex) {
                //如果用户输入的数量不是数字，显示一个错误对话框
                JOptionPane.showMessageDialog(this, "数量必须为数字", "错误", JOptionPane.ERROR_MESSAGE);
            } catch (Exception ex) {
                //如果用户输入的信息不完整，显示一个错误对话框
                JOptionPane.showMessageDialog(this, "输入不完整", "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    //删除图书的方法，接受一个字符串参数，表示要删除的图书的类型（书号、书名或作者）
    private void deleteBook(String type) {
        //创建一个对话框，用于输入要删除的图书的信息
        //this表示当前窗口，即MainFrame对象
        //"请输入要删除的" + type + ":"表示对话框的提示信息
        //JOptionPane.showInputDialog方法用于显示一个输入对话框，返回用户输入的内容
        //key变量用于存储用户输入的内容
        String key = JOptionPane.showInputDialog(this, "请输入要删除的" + type + ":");
        if (key != null && !key.isEmpty()) {//如果用户输入了内容
            //调用图书管理器的deleteBooks方法，删除指定类型和关键字的图书
            //count变量用于存储删除的图书数量
            //如果删除的图书数量大于0，显示一个对话框，提示删除成功
            //否则，显示一个对话框，提示未找到匹配的图书
            int count = manager.deleteBooks(type, key);
            if (count > 0) {
                JOptionPane.showMessageDialog(this, "成功删除 " + count + " 本图书");
            } else {
                JOptionPane.showMessageDialog(this, "未找到匹配的图书");
            }
        }
    }

    //借阅图书的方法
    private void borrowBook() {
        //创建一个对话框，用于输入要借阅的图书的信息
        //this表示当前窗口，即MainFrame对象
        //"输入要借阅的书号:"表示对话框的提示信息
        //JOptionPane.showInputDialog方法用于显示一个输入对话框，返回用户输入的内容
        //id变量用于存储用户输入的内容
        //如果用户输入了内容，调用图书管理器的borrowBook方法，借阅指定书号的图书
        //如果借阅成功，显示一个对话框，提示借阅成功
        //否则，显示一个对话框，提示借阅失败
        String id = JOptionPane.showInputDialog(this, "输入要借阅的书号:");
        if (id != null && !id.isEmpty()) {
            JOptionPane.showMessageDialog(this, manager.borrowBook(id));
        }
    }

    //归还图书的方法
    private void returnBook() {
        //创建一个对话框，用于输入要归还的图书的信息
        //this表示当前窗口，即MainFrame对象
        //"输入要归还的书号:"表示对话框的提示信息
        //JOptionPane.showInputDialog方法用于显示一个输入对话框，返回用户输入的内容
        //id变量用于存储用户输入的内容
        //如果用户输入了内容，调用图书管理器的returnBook方法，归还指定书号的图书
        //如果归还成功，显示一个对话框，提示归还成功
        //否则，显示一个对话框，提示归还失败
        String id = JOptionPane.showInputDialog(this, "输入要归还的书号:");
        if (id != null && !id.isEmpty()) {
            JOptionPane.showMessageDialog(this, manager.returnBook(id));
        }
    }

    //查询图书的方法，接受一个字符串参数，表示要查询的图书的类型（书号、书名或作者）
    private void searchBook(String type) {
        //创建一个对话框，用于输入要查询的图书的信息
        //this表示当前窗口，即MainFrame对象
        //"请输入"+type+":"表示对话框的提示信息
        //JOptionPane.showInputDialog方法用于显示一个输入对话框，返回用户输入的内容
        //key变量用于存储用户输入的内容
        //如果用户输入了内容，调用图书管理器的searchBooks方法，查询指定类型和关键字的图书
        //如果查询到了图书，调用showResults方法，显示查询结果
        //否则，显示一个对话框，提示未找到匹配的图书
        String key = JOptionPane.showInputDialog(this, "请输入"+type+":");
        if (key != null && !key.isEmpty()) {
            showResults(manager.searchBooks(type, key));
        }
    }

    //显示所有图书的方法
    private void showAll() {
        //调用图书管理器的getAllBooks方法，获取所有图书的信息
        showResults(manager.getAllBooks());
    }

    //显示查询结果的方法，接受一个Book对象的列表作为参数
    private void showResults(java.util.List<Book> books) {
        //如果查询结果为空，显示一个对话框，提示未找到匹配的图书
        //否则，创建一个JTable对象，用于显示查询结果

        if (books.isEmpty()) {
            JOptionPane.showMessageDialog(this, "未找到相关书籍");
            return;
        }

        //JTable是一个表格组件，用于显示二维数据
        //Object[][] data = new Object[books.size()][4];用于存储查询结果的二维数组
        //String[] columns = {"书号", "书名", "作者", "可借数量"};用于存储表格的列名
        //遍历查询结果，将图书的信息存储到data数组中
        //JTable table = new JTable(data, columns);用于创建一个JTable对象，显示查询结果
        String[] columns = {"书号", "书名", "作者", "可借数量"};
        Object[][] data = new Object[books.size()][4];
        for (int i = 0; i < books.size(); i++) {
            //Book b = books.get(i);用于获取查询结果中的第i本书
            Book b = books.get(i);
            //将图书的信息存储到data数组中
            data[i] = new Object[]{b.id, b.title, b.author, b.availableCount};
        }

        //用于创建一个JTable对象(表格组件)，显示查询结果
        JTable table = new JTable(data, columns) {
            //isCellEditable方法用于判断表格中的单元格是否可编辑
            //返回false表示表格中的单元格不可编辑
            public boolean isCellEditable(int row, int column) {
                return false;
            }
        };

        //用于创建一个JScrollPane对象(滚动面板组件)，用于显示JTable对象
        //JScrollPane scrollPane = new JScrollPane(table);用于创建一个JScrollPane对象，显示JTable对象
        JScrollPane scrollPane = new JScrollPane(table);
        //用于设置JScrollPane对象的首选大小
        //scrollPane.setPreferredSize(new Dimension(500, 300));用于设置JScrollPane对象的首选大小
        //JOptionPane.showMessageDialog(this, scrollPane, "查询结果",JOptionPane.PLAIN_MESSAGE);用于显示一个对话框，显示查询结果
        //JOptionPane.PLAIN_MESSAGE表示对话框的样式，即普通的消息框
        scrollPane.setPreferredSize(new Dimension(500, 300));
        JOptionPane.showMessageDialog(this, scrollPane, "查询结果",
                JOptionPane.PLAIN_MESSAGE);
    }

    //退出系统的方法
    private void exitSystem() {
        //调用图书管理器的saveBooks方法，保存图书信息
        //System.exit(0);用于退出程序
        manager.saveBooks();
        System.exit(0);
    }
}


// 图书管理类,用于管理图书的信息
class BookManager {
    //用于存储图书信息的列表
    private java.util.List<Book> books = new ArrayList<>();

    // 构造方法,用于加载图书信息
    public void loadBooks() {
        books.clear();//清空图书列表
        // 从文件中读取图书信息
        try (Scanner sc = new Scanner(new File("selfStudy\\schoolWork\\JavaShiXun\\books.txt"))) {
            while (sc.hasNextLine()) {//hasNextLine()用于判断是否还有下一行
                String[] parts = sc.nextLine().split(",");
                if (parts.length == 4) {
                    books.add(new Book(
                            parts[0].trim(),
                            parts[1].trim(),
                            parts[2].trim(),
                            //Integer.parseInt(parts[3].trim())用于将字符串转换为整数
                            Integer.parseInt(parts[3].trim())
                    ));
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("book.txt数据文件不存在");
        }
    }

    // 保存图书信息到文件
    public void saveBooks() {
        // 写入图书信息到文件
        try (PrintWriter pw = new PrintWriter("selfStudy\\schoolWork\\JavaShiXun\\books.txt")) {
            // 写入表头
            for (Book b : books) {
                pw.println(String.join(",",//join()用于将字符串数组中的元素用指定的分隔符连接起来
                        b.id,
                        b.title,
                        b.author,
                        //String.valueOf(b.availableCount)用于将整数转换为字符串
                        String.valueOf(b.availableCount)
                ));
            }
        } catch (FileNotFoundException e) {
            //books.txt数据文件不存在,弹出对话框提示用户数据保存失败
            JOptionPane.showMessageDialog(null, "数据保存失败");
            //null表示对话框会默认置于屏幕中央，且不依赖任何特定窗口。
        }
    }

    // 添加或更新图书信息
    public void addBook(Book newBook) {
        //如果图书列表中已经存在该图书,则更新图书信息,否则添加新图书信息
        //books.removeIf(b -> b.id.equalsIgnoreCase(newBook.id));用于删除图书列表中已经存在的该图书
        //books.add(newBook);用于添加新图书信息
        //saveBooks();用于保存图书信息到文件
        books.removeIf(b -> b.id.equalsIgnoreCase(newBook.id));
      /*     books.removeIf(new Predicate<Book>() { //Predicate是一个函数式接口,用于判断一个对象是否满足某个条件
                //test()用于判断一个对象是否满足某个条件
                //b.id.equalsIgnoreCase(newBook.id)用于判断两个图书的书号是否相同
                @Override
                public boolean test(Book b) {
                    return b.id.equalsIgnoreCase(newBook.id);
                }
            }); */
        books.add(newBook);
        saveBooks();
    }

    // 借阅图书
    public String borrowBook(String id) {
        //遍历图书列表,如果图书存在且可借数量大于0,则借阅图书,否则返回借阅失败信息
        //b.availableCount--;用于借阅图书,可借数量减1
        //saveBooks();用于保存图书信息到文件
        //return "《" + b.title + "》借阅成功";用于返回借阅成功信息
        //return "《" + b.title + "》库存不足";用于返回借阅失败信息
        //return "书号不存在";用于返回借阅失败信息
        for (Book b : books) {
            if (b.id.equalsIgnoreCase(id)) {
                if (b.availableCount > 0) {
                    b.availableCount--;
                    saveBooks();
                    return "《" + b.title + "》借阅成功";
                }
                return "《" + b.title + "》库存不足";
            }
        }
        return "书号不存在";
    }

    // 归还图书
    public String returnBook(String id) {
        //遍历图书列表,如果图书存在,则归还图书,否则返回归还失败信息
        //b.availableCount++;用于归还图书,可借数量加1
        //saveBooks();用于保存图书信息到文件
        //return "《" + b.title + "》归还成功";用于返回归还成功信息
        //return "书号不存在";用于返回归还失败信息
        for (Book b : books) {
            if (b.id.equalsIgnoreCase(id)) {
                b.availableCount++;
                saveBooks();
                return "《" + b.title + "》归还成功";
            }
        }
        return "书号不存在";
    }

    // 删除图书
    //type:要删除的图书的类型（书号、书名或作者）
    //key:要删除的图书的关键字
    //返回值:删除的图书数量
    public int deleteBooks(String type, String key) {
        //遍历图书列表,如果图书存在且符合删除条件,则删除图书
        //books.removeIf(b -> b.id.equalsIgnoreCase(key));用于删除图书列表中符合删除条件的图书
        //saveBooks();用于保存图书信息到文件
        //return initialSize - books.size();用于返回删除的图书数量
        int initialSize = books.size();
        switch(type) {
            case "书号": books.removeIf(b -> b.id.equalsIgnoreCase(key)); break;
            case "书名": books.removeIf(b -> b.title.equalsIgnoreCase(key)); break;
            case "作者": books.removeIf(b -> b.author.equalsIgnoreCase(key)); break;
        }
        //如果删除的图书种类数量大于0,则保存图书信息到文件并返回删除的图书种类数
        if (initialSize != books.size()) saveBooks();
        return initialSize - books.size();
    }

    // 查询图书
    //type:要查询的图书的类型（书号、书名或作者）
    //key:要查询的图书的关键字
    //返回值:查询到的图书列表
    public java.util.List<Book> searchBooks(String type, String key) {
        //遍历图书列表,如果图书存在且符合查询条件,则将图书添加到查询结果列表中
        java.util.List<Book> result = new ArrayList<>();
        //将关键字转换为小写
        String lowerKey = key.toLowerCase();
        //遍历图书列表,如果图书存在且符合查询条件,则将图书添加到查询结果列表中
        //switch(type)用于根据查询类型执行不同的查询操作
        //b.id.toLowerCase().contains(lowerKey):用于判断图书的书号是否包含关键字
        //b.title.toLowerCase().contains(lowerKey):用于判断图书的书名是否包含关键字
        //b.author.toLowerCase().contains(lowerKey):用于判断图书的作者是否包含关键字
        for (Book b : books) {
            switch(type) {
                case "书号": if (b.id.toLowerCase().contains(lowerKey)) result.add(b); break;
                case "书名": if (b.title.toLowerCase().contains(lowerKey)) result.add(b); break;
                case "作者": if (b.author.toLowerCase().contains(lowerKey)) result.add(b); break;
            }
        }
        return result;//返回查询结果列表
    }

    // 获取所有图书信息
    //返回值:所有图书的列表
    public java.util.List<Book> getAllBooks() {
        return new ArrayList<>(books);
    }
}


// 图书类,用于表示图书的信息
 class Book {
    String id;
    String title;
    String author;
    int availableCount;

    public Book(String id, String title, String author, int count) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.availableCount = count;
    }
}